I think the hints are unnecessarily cryptic because they are not complete sentences. They are written like Kevin from the Office when he tried to save time by omitting some words from a sentence.

I really like the explanation in this article. Initially, I thought it would going to be tough. But it's more about the maths behind it.

Java, sliding window O(n) solution

class Solution {
    public int minSwaps(int[] data) {
        // `ones` will also serve as the size for our sliding window
        int ones = Arrays.stream(data).sum();
        
        int runningOnes = 0;
        // Count 1s in first `ones` elements
        for (int i = 0; i < ones; i++) {
            runningOnes += data[i];
        }
        int swapsRequired = ones - runningOnes;
        for (int i = ones; i < data.length; i++) {
            // Drop leftmost from sliding window, and accumulate next right
            runningOnes = runningOnes - data[i-ones] + data[I];
            // runningOnes holds 1s seen in current window
            swapsRequired = Math.min(swapsRequired, ones - runningOnes);
        }
        return swapsRequired;
    }
}

Great video. Thanks.

The solution 2 consumes more space but doesn't add benefits. It is useful just to show there are alternatives, but not good alternatives :-)

One pointer only:

class Solution:
    def minSwaps(self, data: List[int]) -> int:
        window = data.count(1)
        zeros, ans = 0, float('inf')
        for i, d in enumerate(data):
            if d == 0: zeros += 1
            if i >= window - 1:
                if i >= window and data[i - window] == 0:
                    zeros -= 1
                ans = min(ans, zeros)
        return ans

Basically the idea is we want to create a window of however many ones there are in the array. We assume a certain substring contains all ones. If we assume everything to be ones within our sliding window (without actually changing the value) the number of swaps will be equal to the total number of 1s subtracted with the number of 1s inside our sliding window. We care about the ones outside our sliding window since those values will have to be swapped to zeros. The values that are alread zero outside the window do not matter. Its a unique case where we care about things outside our window instead of inside it. Don't let it trip you up.

 public int minSwaps(int[] data) {
        int totalOnes = 0, totalZeros = 0;
        for (int i = 0; i < data.length; i++) {
            if (data[i] == 1) totalOnes++;
            else totalZeros++;
        }
        if (totalOnes == 1) return 0;
        
        int right = totalOnes - 1, left = 0, min = Integer.MAX_VALUE, localOnes = 0, localZeros = 0;
        
        for (int i = 0; i < totalOnes; i++) {
            if (data[i] == 0) localZeros++;
            else localOnes++;
        }
                
        while (right < data.length) {
            int onesOutSideWindow = totalOnes - localOnes;
            min = Math.min(onesOutSideWindow, min);
            
            if (right + 1 >= data.length) break;
            
            if (data[++right] == 0) localZeros++;
            else localOnes++;
            
            if (data[left++] == 1) localOnes--;
            else localZeros--;
        }

        return min;
    }

What's the underlying math support here? The intuition is that the minimum swaps of each subarray window equals to the number of zeros. This is not always true. E.g. [1, 0, 0, 1, 1]. For the first subarray window "[1, 0, 0]", the minimum number of swaps is two as we have two 0s here. But it is actually one as we can swap "0, 0" with "1, 1" through one swap.

This is the prefix sum solution using the sliding window method.

int minSwaps(vector<int>& data) {
        vector<int> pf(data.size());
        partial_sum(data.begin(), data.end(), pf.begin());
        pf.insert(pf.begin(), 0);
        int ones = pf.back();
        int j=ones; int i=0;
        int max_ones=INT_MIN;
        while (j<pf.size()){
            max_ones=max(max_ones, pf[j]-pf[i]);
            i++; j++;
        }
        return ones-max_ones;
    }

First count ones, fill a window of ones and swaps needed (zeros need to be swapped out) and then keep sliding window and compute minSwap:

class Solution {
    public int minSwaps(int[] data) {
        if (data == null || data.length < 2) return 0;
        int ones = 0;
        for (int i = 0; i < data.length; i++) {
            if (data[i] == 1) ones++;
        }
        int swaps = 0;
        for (int i = 0; i < ones; i++) {
            if (data[i] == 0) swaps++;
        }
        int res = data.length-ones;
        for (int i = ones; i < data.length; i++) {
            res = Math.min(res, swaps);
            if (data[i-ones] == 0) swaps--;
            if (data[i] == 0) swaps++;
        }
        res = Math.min(res, swaps);
        return res;
    }
}